home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / rpc / AbstractInvoker.as next >
Encoding:
Text File  |  2008-05-21  |  6.2 KB  |  191 lines
  1. package mx.rpc
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.getQualifiedClassName;
  6.    import mx.core.mx_internal;
  7.    import mx.logging.ILogger;
  8.    import mx.logging.Log;
  9.    import mx.messaging.errors.MessagingError;
  10.    import mx.messaging.events.MessageEvent;
  11.    import mx.messaging.events.MessageFaultEvent;
  12.    import mx.messaging.messages.AsyncMessage;
  13.    import mx.messaging.messages.IMessage;
  14.    import mx.rpc.events.AbstractEvent;
  15.    import mx.rpc.events.FaultEvent;
  16.    import mx.rpc.events.InvokeEvent;
  17.    import mx.rpc.events.ResultEvent;
  18.    import mx.utils.ObjectProxy;
  19.    import mx.utils.Translator;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class AbstractInvoker extends EventDispatcher
  24.    {
  25.       mx_internal static const BINDING_RESULT:String = "resultForBinding";
  26.       
  27.       private static const TRANSLATOR:Translator = Translator.getDefaultInstanceFor(AbstractInvoker);
  28.       
  29.       private var _log:ILogger;
  30.       
  31.       private var _asyncRequest:AsyncRequest;
  32.       
  33.       mx_internal var activeCalls:ActiveCalls;
  34.       
  35.       mx_internal var _result:Object;
  36.       
  37.       mx_internal var _makeObjectsBindable:Boolean;
  38.       
  39.       public function AbstractInvoker()
  40.       {
  41.          super();
  42.          _log = Log.getLogger("mx.rpc.AbstractInvoker");
  43.          mx_internal::activeCalls = new ActiveCalls();
  44.       }
  45.       
  46.       mx_internal function get asyncRequest() : AsyncRequest
  47.       {
  48.          if(_asyncRequest == null)
  49.          {
  50.             _asyncRequest = new AsyncRequest();
  51.          }
  52.          return _asyncRequest;
  53.       }
  54.       
  55.       mx_internal function processResult(param1:IMessage, param2:AsyncToken) : Boolean
  56.       {
  57.          var _loc3_:Object = null;
  58.          _loc3_ = param1.body;
  59.          if(makeObjectsBindable && _loc3_ != null && getQualifiedClassName(_loc3_) == "Object")
  60.          {
  61.             mx_internal::_result = new ObjectProxy(_loc3_);
  62.          }
  63.          else
  64.          {
  65.             mx_internal::_result = _loc3_;
  66.          }
  67.          return true;
  68.       }
  69.       
  70.       mx_internal function faultHandler(param1:MessageFaultEvent) : void
  71.       {
  72.          var _loc2_:MessageEvent = null;
  73.          var _loc3_:AsyncToken = null;
  74.          var _loc4_:Fault = null;
  75.          _loc2_ = MessageEvent.createEvent(MessageEvent.MESSAGE,param1.message);
  76.          _loc3_ = mx_internal::preHandle(_loc2_);
  77.          if(_loc3_ == null && AsyncMessage(param1.message).correlationId != null && AsyncMessage(param1.message).correlationId != "" && param1.faultCode != "Client.Authentication")
  78.          {
  79.             return;
  80.          }
  81.          _loc4_ = new Fault(param1.faultCode,param1.faultString,param1.faultDetail);
  82.          _loc4_.rootCause = param1.rootCause;
  83.          mx_internal::dispatchRpcEvent(FaultEvent.createEvent(_loc4_,_loc3_,param1.message));
  84.       }
  85.       
  86.       public function cancel() : void
  87.       {
  88.          mx_internal::activeCalls.cancelLast();
  89.       }
  90.       
  91.       [Bindable("resultForBinding")]
  92.       public function get lastResult() : Object
  93.       {
  94.          return mx_internal::_result;
  95.       }
  96.       
  97.       mx_internal function dispatchRpcEvent(param1:AbstractEvent) : void
  98.       {
  99.          param1.mx_internal::callTokenResponders();
  100.          if(!param1.isDefaultPrevented())
  101.          {
  102.             dispatchEvent(param1);
  103.          }
  104.       }
  105.       
  106.       mx_internal function getNetmonId() : String
  107.       {
  108.          return null;
  109.       }
  110.       
  111.       public function clearResult(param1:Boolean = true) : void
  112.       {
  113.          mx_internal::_result = null;
  114.          if(param1)
  115.          {
  116.             dispatchEvent(new Event(mx_internal::BINDING_RESULT));
  117.          }
  118.       }
  119.       
  120.       mx_internal function set asyncRequest(param1:AsyncRequest) : void
  121.       {
  122.          _asyncRequest = param1;
  123.       }
  124.       
  125.       mx_internal function preHandle(param1:MessageEvent) : AsyncToken
  126.       {
  127.          return mx_internal::activeCalls.removeCall(AsyncMessage(param1.message).correlationId);
  128.       }
  129.       
  130.       mx_internal function resultHandler(param1:MessageEvent) : void
  131.       {
  132.          var _loc2_:AsyncToken = null;
  133.          _loc2_ = mx_internal::preHandle(param1);
  134.          if(_loc2_ == null)
  135.          {
  136.             return;
  137.          }
  138.          if(mx_internal::processResult(param1.message,_loc2_))
  139.          {
  140.             dispatchEvent(new Event(mx_internal::BINDING_RESULT));
  141.             mx_internal::dispatchRpcEvent(ResultEvent.createEvent(mx_internal::_result,_loc2_,param1.message));
  142.          }
  143.       }
  144.       
  145.       mx_internal function invoke(param1:IMessage, param2:AsyncToken = null) : AsyncToken
  146.       {
  147.          var fault:Fault = null;
  148.          var message:IMessage = param1;
  149.          var token:AsyncToken = param2;
  150.          if(token == null)
  151.          {
  152.             token = new AsyncToken(message);
  153.          }
  154.          else
  155.          {
  156.             token.mx_internal::setMessage(message);
  157.          }
  158.          mx_internal::activeCalls.addCall(message.messageId,token);
  159.          try
  160.          {
  161.             mx_internal::asyncRequest.invoke(message,new Responder(mx_internal::resultHandler,mx_internal::faultHandler));
  162.             mx_internal::dispatchRpcEvent(InvokeEvent.createEvent(token,message));
  163.          }
  164.          catch(e:MessagingError)
  165.          {
  166.             _log.warn(e.toString());
  167.             fault = new Fault("InvokeFailed",e.toString(),TRANSLATOR.textOf("cannotConnectToDestination",mx_internal::asyncRequest.destination));
  168.             new AsyncDispatcher(mx_internal::dispatchRpcEvent,[FaultEvent.createEvent(fault,token,message)],10);
  169.          }
  170.          catch(e2:Error)
  171.          {
  172.             _log.warn(e2.toString());
  173.             fault = new Fault("InvokeFailed",e2.message);
  174.             new AsyncDispatcher(mx_internal::dispatchRpcEvent,[FaultEvent.createEvent(fault,token,message)],10);
  175.          }
  176.          return token;
  177.       }
  178.       
  179.       public function set makeObjectsBindable(param1:Boolean) : void
  180.       {
  181.          mx_internal::_makeObjectsBindable = param1;
  182.       }
  183.       
  184.       public function get makeObjectsBindable() : Boolean
  185.       {
  186.          return mx_internal::_makeObjectsBindable;
  187.       }
  188.    }
  189. }
  190.  
  191.